home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 November: Tool Chest / Dev.CD Nov 00 TC Disk 1.toast / Sample Code / Graphics 2D / New NewGWorld / New NewGWorld.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-28  |  19.8 KB  |  684 lines  |  [TEXT/CWIE]
  1. /*
  2.     File:        New NewGWorld.c
  3.  
  4.     Contains:    Sample application demonstrating the use of the new version of the NewGWorld routine
  5.  
  6.     Written by:    ggs
  7.  
  8.     Copyright:    Copyright (c) 1999 Apple Computer, Inc., All Rights Reserved.
  9.  
  10.                 You may incorporate this Apple sample source code into your program(s) without
  11.                 restriction. This Apple sample source code has been provided "AS IS" and the
  12.                 responsibility for its operation is yours. You are not permitted to redistribute
  13.                 this Apple sample source code as "Apple sample source code" after having made
  14.                 changes. If you're going to re-distribute the source, we require that you make
  15.                 it clear in the source that the code was descended from Apple sample source
  16.                 code, but that you've made changes.
  17.                 
  18.     Change History (most recent first):
  19.                 08/2000        JM                Carbonized, non-Carbon code is commented out
  20.                                             for demonstration purposes.
  21.  
  22. */
  23.  
  24. #include "CarbonPrefix.h"
  25. // system includes ----------------------------------------------------------
  26.  
  27. #include <MacMemory.h>
  28. #include <Events.h>
  29. #include <Fonts.h>
  30. #include <Windows.h>
  31. #include <TextEdit.h>
  32. #include <Dialogs.h>
  33. #include <Devices.h>
  34. #include <Sound.h>
  35. #include <SoundInput.h>
  36. #include <ToolUtils.h>
  37. #include <OSUtils.h>
  38. #include <LowMem.h>
  39. #include <Gestalt.h>
  40.  
  41. #include <stdlib.h>
  42.  
  43. // project includes ---------------------------------------------------------
  44.  
  45.  
  46.  
  47. // statics/globals (internal only) ------------------------------------------
  48.  
  49. // Menu defs
  50. enum 
  51. {
  52.     kMenuApple = 128,
  53.     kMenuFile = 129,
  54.     
  55.     kAppleAbout = 1,    
  56.     kFileInVRAM = 1,                        // allocate buffer in VRAM
  57.     kFileInAGP,                                // allocate buffer in AGP memory
  58.     kFileInSystem,                            // allocate buffer in system memory
  59.     kFileTest,                                // run blitting test
  60.     kFileQuit                                // quit
  61. };
  62.  
  63. enum
  64. {
  65.                                             // Initial Window Constants
  66.     kWindowHeight = 400,                    //   "
  67.     kWindowWidth = 500,                        //   "
  68.     kWindowOffset = 100                        //   "
  69. };
  70.  
  71. enum
  72. {
  73.     kNoWhere = 0,                            // where is the off screen
  74.     kInVRAM,
  75.     kInAGP,
  76.     kInSystem
  77. };
  78.  
  79. Boolean gDone = false;                        // is app done
  80. SInt32 gSleepTime = 60;                        // yield time
  81.  
  82. WindowPtr gpWindow = NULL;                    // main window
  83. GWorldPtr gpGWOffScreen = NULL;                // main window offscreen scratch
  84. short gwLocOffscreen = 0;                    // curretn offscreen location
  85.  
  86. Boolean gNewNewGWorld = false;                // can we allocate in VRAm or AGP memory?
  87.  
  88.  
  89. // functions Prototypes (internal/private) -----------------------------------
  90.  
  91. // returns GDHandle that window resides on (most of it anyway)
  92. GDHandle GetWindowDevice (WindowPtr pWindow);
  93. // checks and allocates (if required) a new GWorld size of pWindow in memory type target; returns true if (re)allocated
  94. Boolean BuildOffscreen (GWorldPtr * ppGWorld, WindowPtr pWindow, short * target);
  95. // fills offscreen buffer with random bright color
  96. void FillOffscreen (GWorldPtr pGWorld);
  97. // checks offscreen and blits it to the front
  98. void BlitToWindow (GWorldPtr pGWorld, WindowPtr pWindow, short * pLocation);
  99. // checks buffer and then runs 200 iteration CopyBits test offscreen to on and reprots results
  100. void RunTest (void);
  101. // Forces offscreen allocation (if different than current) in memory type specified and sets menu flag
  102. void AllocBuffer (short target);
  103.  
  104. // standard stuff
  105. void InitToolbox(void);                                                    // standard inits
  106. Boolean SetUp (void);                                                    // application setup
  107. void DoMenu (SInt32 menuResult);                                        // menu event handler
  108. void DoKey (SInt8 theKey, SInt8 theCode);                                // key down handling
  109. void DoUpdate (WindowPtr pWindow);                                        // draw from off screen to on and updates control postions on screen for events
  110. void DoEvent (void);                                                    // event handler
  111. void CleanUp (void);                                                    // clean ups after application
  112.  
  113. // functions (internal/private) ---------------------------------------------
  114.  
  115. // returns GDHandle that window resides on (most of it anyway)
  116.  
  117. GDHandle GetWindowDevice (WindowPtr pWindow)
  118. {
  119.     GrafPtr pgpSave;
  120.     Rect rectWind, rectSect;
  121.     long greatestArea, sectArea;
  122.     GDHandle hgdNthDevice, hgdZoomOnThisDevice;
  123.     
  124.     GetPort (&pgpSave);
  125.     //SetPort (pWindow);
  126.     SetPortWindowPort (pWindow);
  127.     //rectWind = pWindow->portRect;
  128.     GetPortBounds(GetWindowPort(pWindow), &rectWind);
  129.     LocalToGlobal ((Point*)& rectWind.top);    // convert to global coordinates
  130.     LocalToGlobal ((Point*)& rectWind.bottom);
  131.     hgdNthDevice = GetDeviceList ();
  132.     greatestArea = 0;     // initialize to 0
  133.     // check window against all gdRects in gDevice list and remember 
  134.     //  which gdRect contains largest area of window}
  135.     while (hgdNthDevice)
  136.     {
  137.         if (TestDeviceAttribute (hgdNthDevice, screenDevice))
  138.             if (TestDeviceAttribute (hgdNthDevice, screenActive))
  139.             {
  140.                 // The SectRect routine calculates the intersection 
  141.                 //  of the window rectangle and this gDevice 
  142.                 //  rectangle and returns TRUE if the rectangles intersect, 
  143.                 //  FALSE if they don't.
  144.                 SectRect(&rectWind, &(**hgdNthDevice).gdRect, &rectSect);
  145.                 // determine which screen holds greatest window area
  146.                 //  first, calculate area of rectangle on current device
  147.                 sectArea = (long)(rectSect.right - rectSect.left) * (rectSect.bottom - rectSect.top);
  148.                 if ( sectArea > greatestArea )
  149.                 {
  150.                     greatestArea = sectArea;    // set greatest area so far
  151.                     hgdZoomOnThisDevice = hgdNthDevice;    // set zoom device
  152.                 }
  153.                 hgdNthDevice = GetNextDevice(hgdNthDevice);
  154.             }
  155.     }     // of WHILE
  156.     SetPort (pgpSave);
  157.     return hgdZoomOnThisDevice;
  158. }
  159.  
  160. // --------------------------------------------------------------------------
  161.  
  162. // checks and allocates (if required) a new GWorld size of pWindow in memory type target; returns true if (re)allocated
  163. // Currently, this routine checks to see if the GWorld is NULL, the PixMap is NULL, the baseAddr is NULL, the GDevice of the PixMap
  164. //   and the window do not match, and if the color depths are not the same.  If any of the previous is true the GWorld is re-allocated.
  165.  
  166. Boolean BuildOffscreen (GWorldPtr * ppGWorld, WindowPtr pWindow, short * location)
  167. { 
  168.     GDHandle hgdWindow = GetWindowDevice (pWindow);    // window GDevice
  169.     //short wPixDepth = (**((CGrafPtr)pWindow)->portPixMap).pixelSize; // window pixel depth
  170.     short wPixDepth = (**(GetPortPixMap(GetWindowPort(pWindow)))).pixelSize;
  171.     Boolean fMustRebuild = false;
  172.     Rect    tempRect1;
  173.     
  174.     if (NULL == *ppGWorld) // if GWorld passed in is not allocated
  175.         fMustRebuild = true;
  176.     else
  177.     {
  178.         PixMapHandle hPixmap = GetGWorldPixMap (*ppGWorld);
  179.         if ((NULL == hPixmap) || (NULL == GetPixBaseAddr (hPixmap))) // if pixmap handle is NULL or pixmap base address is NULL
  180.             fMustRebuild = true;
  181.         else if (GetGWorldDevice(*ppGWorld) != hgdWindow) // if GWorld not on same device as window
  182.             fMustRebuild = true;
  183.         else if ((**hPixmap).pixelSize != wPixDepth) // if color depths are not the same
  184.             fMustRebuild = true;
  185.     }
  186.     
  187.     if (fMustRebuild) // must rebuild
  188.     {    
  189.         if (NULL != *ppGWorld) // if we have an allocated GWorld
  190.         {
  191.             DisposeGWorld (*ppGWorld);    // dump our current GWorld
  192.             *ppGWorld = NULL;
  193.         }
  194.         switch (*location) // where to we want to put it
  195.         {
  196.             case kInVRAM:
  197.                 //if (noErr == NewGWorld (ppGWorld, wPixDepth, &pWindow->portRect, NULL, hgdWindow, noNewDevice | useDistantHdwrMem))                
  198.                 if (noErr == NewGWorld (ppGWorld, wPixDepth, GetPortBounds(GetWindowPort(pWindow), &tempRect1), NULL, hgdWindow, noNewDevice | useDistantHdwrMem))        
  199.                     break;
  200.                 // we failed with VRAM, signal that and drop to AGP
  201.                 SysBeep (30);
  202.                 *location = kInAGP;
  203.             case kInAGP:
  204.                 //if (noErr == NewGWorld (ppGWorld, wPixDepth, &pWindow->portRect, NULL, hgdWindow, noNewDevice | useLocalHdwrMem))
  205.                 if (noErr == NewGWorld (ppGWorld, wPixDepth, GetPortBounds(GetWindowPort(pWindow), &tempRect1), NULL, hgdWindow, noNewDevice | useLocalHdwrMem))
  206.                     break;
  207.                 // we failed with AGP, signal that and drop to system memory
  208.                 SysBeep (30);
  209.                 *location = kInSystem;
  210.             case kInSystem:
  211.             default:
  212.                 //if (noErr != NewGWorld (ppGWorld, wPixDepth, &pWindow->portRect, NULL, hgdWindow, noNewDevice | keepLocal))
  213.                 if (noErr != NewGWorld (ppGWorld, wPixDepth, GetPortBounds(GetWindowPort(pWindow), &tempRect1), NULL, hgdWindow, noNewDevice | keepLocal))
  214.                 {
  215.                     // we failed with system thus we can't allocate our GWorld, signal that, indicate no location and drop to debugger
  216.                     SysBeep (30);
  217.                     *location = kNoWhere;
  218.                     DebugStr ("\pUnable to allocate off screen image");
  219.                     return false; // nothing was allocated
  220.                 }
  221.         } 
  222.         return true; // we rebuilt our GWorld
  223.     }
  224.     return false; // everything is okay
  225. }
  226.  
  227. // --------------------------------------------------------------------------
  228.  
  229. // fills offscreen buffer with random bright color
  230.  
  231. void FillOffscreen (GWorldPtr pGWorld)
  232. {
  233.     static RGBColor rgbColorOld;
  234.     GDHandle hGDSave;
  235.     CGrafPtr pCGrafSave;
  236.     Rect rectSource /*= (pGWorld->portRect)*/;
  237.     RGBColor rgbColor;
  238.     
  239.     GetPortBounds(pGWorld, &rectSource);
  240.     
  241.     do 
  242.         rgbColor.red = (Random () + 32767) / 2 + 32767;
  243.     while (abs (rgbColor.red - rgbColorOld.red) <  3000);    
  244.     do 
  245.         rgbColor.green = (Random () + 32767) / 2 + 32767;
  246.     while (abs (rgbColor.green - rgbColorOld.green) <  3000);
  247.     do 
  248.         rgbColor.blue = (Random () + 32767) / 2 + 32767;
  249.     while (abs (rgbColor.blue - rgbColorOld.blue) <  3000);
  250.     
  251.     rgbColorOld = rgbColor;
  252.  
  253.     GetGWorld (&pCGrafSave, &hGDSave);
  254.     SetGWorld (pGWorld, NULL);
  255.     if (LockPixels (GetGWorldPixMap (pGWorld)))
  256.     {
  257.         // draw some background
  258.         EraseRect (&rectSource);
  259.         RGBForeColor (&rgbColor);
  260.         PaintRect (&rectSource);
  261.         UnlockPixels (GetGWorldPixMap (pGWorld));
  262.     }
  263.     SetGWorld (pCGrafSave, hGDSave);
  264. }
  265.  
  266. // --------------------------------------------------------------------------
  267.  
  268. // checks offscreen and blits it to the front
  269.  
  270. void BlitToWindow (GWorldPtr pGWorld, WindowPtr pWindow, short * pLocation)
  271. {
  272.     Rect rectDest /*= ((GrafPtr)pWindow)->portRect*/;
  273.     Rect rectSource /*= ((GrafPtr)pWindow)->portRect*/;
  274.     GrafPtr pCGrafSave;
  275.     
  276.     GetPortBounds(GetWindowPort(pWindow), &rectDest);
  277.     GetPortBounds(GetWindowPort(pWindow), &rectSource);
  278.     
  279.     // check to ensure we have a valid offscreen and rebuild if required
  280.     if (BuildOffscreen (&pGWorld, pWindow, pLocation))
  281.         FillOffscreen (pGWorld);
  282.     
  283.     // blit
  284.     GetPort (&pCGrafSave);
  285.     //SetPort ((GrafPtr) pWindow);
  286.     SetPortWindowPort(pWindow);
  287.     if (LockPixels (GetGWorldPixMap (pGWorld)))
  288.     {
  289.         //CopyBits (&((GrafPtr)pGWorld)->portBits, &pWindow->portBits, &rectSource, &rectDest, srcCopy, NULL);
  290.         CopyBits (    GetPortBitMapForCopyBits(pGWorld), GetPortBitMapForCopyBits(GetWindowPort(pWindow)), 
  291.                     &rectSource, &rectDest, srcCopy, NULL);
  292.         UnlockPixels (GetGWorldPixMap (pGWorld));
  293.     }
  294.     else
  295.         SysBeep (30);
  296.     SetPort (pCGrafSave);
  297. }
  298.  
  299. // --------------------------------------------------------------------------
  300.  
  301. // checks buffer and then runs 200 iteration CopyBits test offscreen to on and reprots results
  302.  
  303. void RunTest (void)
  304. {
  305.     Str255 str = "\p";
  306.     Rect rectDest /*= ((GrafPtr)gpWindow)->portRect*/;
  307.     Rect rectSource /*= ((GrafPtr)gpWindow)->portRect*/;
  308.     GrafPtr pCGrafSave;
  309.     long time;
  310.     short i;
  311.     
  312.     GetPortBounds(GetWindowPort(gpWindow), &rectDest);
  313.     GetPortBounds(GetWindowPort(gpWindow), &rectSource);
  314.  
  315.     BlitToWindow (gpGWOffScreen, gpWindow, &gwLocOffscreen);
  316.  
  317.     GetPort (&pCGrafSave);
  318.     //SetPort ((GrafPtr) gpWindow); //shouldn't this blow up in carbon?
  319.     SetPortWindowPort(gpWindow);
  320.     if (LockPixels (GetGWorldPixMap (gpGWOffScreen)))
  321.     {
  322.         time = TickCount ();
  323.         for (i = 0; i < 200; i++)
  324.             //CopyBits (&((GrafPtr)gpGWOffScreen)->portBits, &gpWindow->portBits, &rectSource, &rectDest, srcCopy, NULL);
  325.             CopyBits (GetPortBitMapForCopyBits(gpGWOffScreen), GetPortBitMapForCopyBits(GetWindowPort(gpWindow)), &rectSource, &rectDest, srcCopy, NULL);
  326.         time = TickCount () - time;
  327.         time = 200 * 60 / time;
  328.  
  329.         NumToString (rectSource.right - rectSource.left, str);
  330.         MoveTo (10, 20);
  331.         DrawString (str);
  332.         MoveTo (43, 20);
  333.         DrawString ("\px");
  334.         NumToString (rectSource.bottom - rectSource.top, str);
  335.         MoveTo (56, 20);
  336.         DrawString (str);
  337.         NumToString (time, str);
  338.         MoveTo (10, 35);
  339.         DrawString (str);
  340.         MoveTo (48, 35);
  341.         DrawString ("\pfps");
  342.         MoveTo (10, 50);
  343.         switch (gwLocOffscreen)
  344.         {
  345.             case kInVRAM:
  346.                 DrawString ("\pIn VRAM");
  347.                 break;
  348.             case kInAGP:
  349.                 DrawString ("\pIn AGP memory");
  350.                 break;
  351.             case kInSystem:
  352.                 DrawString ("\pIn system memory");
  353.                 break;
  354.             default:
  355.                 break;
  356.         }
  357.         UnlockPixels (GetGWorldPixMap (gpGWOffScreen));
  358.     }
  359.     else
  360.     {
  361.         SysBeep (30);
  362.         MoveTo (10, 20);
  363.         DrawString ("\pBlit test failed.");
  364.     }
  365.     SetPort (pCGrafSave);
  366. }
  367.  
  368. // --------------------------------------------------------------------------
  369.  
  370. // forces offscreen allocation (if different than current) in memory type specified and sets menu flag
  371.  
  372. void AllocBuffer (short location)
  373. {
  374.     MenuHandle hMenu;
  375.     short i;
  376.     
  377.     // check to see if we are allocated in the desired buffer
  378.     if (location != gwLocOffscreen) 
  379.     { 
  380.         // dispose to force a rebuild
  381.         if (gpGWOffScreen)
  382.             DisposeGWorld (gpGWOffScreen);
  383.         gpGWOffScreen = NULL;
  384.         gwLocOffscreen = location;
  385.     }
  386.     // ensure we are properly built
  387.     if (BuildOffscreen (&gpGWOffScreen, gpWindow, &gwLocOffscreen))
  388.     {
  389.         FillOffscreen (gpGWOffScreen);
  390.         BlitToWindow (gpGWOffScreen, gpWindow, &gwLocOffscreen);
  391.     }
  392.     
  393.     // set menus
  394.     hMenu = GetMenuHandle (kMenuFile);
  395.     for (i = kFileInVRAM; i <= kFileInSystem; i++)
  396.         CheckMenuItem (hMenu, i, false);
  397.     CheckMenuItem (hMenu, gwLocOffscreen, true);
  398. }
  399.  
  400. // --------------------------------------------------------------------------
  401.  
  402. void InitToolbox()
  403. {
  404.     MenuHandle menu;
  405.  
  406.     /*MaxApplZone ();
  407.  
  408.     InitGraf((Ptr) &qd.thePort);
  409.     InitFonts();
  410.     InitWindows();
  411.     InitMenus();
  412.     TEInit();
  413.     InitDialogs(nil);*/
  414.     InitCursor();
  415.     
  416.     //qd.randSeed =  TickCount();
  417.     SetQDGlobalsRandomSeed(TickCount());
  418.  
  419.     // Init Menus
  420.     menu = NewMenu (kMenuApple, "\p\024");            // new  apple menu
  421.     InsertMenu (menu, 0);                            // add menu to end
  422.     //AppendResMenu(menu, 'DRVR');
  423.     
  424.     menu = NewMenu (kMenuFile, "\pFile");            // new menu
  425.     InsertMenu (menu, 0);                            // add menu to end
  426.     AppendMenu (menu, "\pAllocate In VRAM;Allocate In AGP Memory;Allocate In System Memory;Run Blit Test;Quit/Q");         // add items
  427.     
  428.     DrawMenuBar();
  429. } 
  430.  
  431. // --------------------------------------------------------------------------
  432.  
  433. Boolean SetUp (void)
  434. {
  435.     Rect rectWindow;
  436.     MenuHandle hMenu;
  437.     long versionSystem;
  438.     short i;
  439.     
  440.     InitToolbox ();
  441.  
  442.     SetRect (&rectWindow, 0, 0, kWindowWidth, kWindowHeight);
  443.     OffsetRect (&rectWindow, kWindowOffset, kWindowOffset);
  444.     gpWindow = NewCWindow (NULL, &rectWindow, "\pNew NewGWorld Test", true, kWindowGrowDocumentProc, (WindowPtr) -1, false, 0);
  445.  
  446.     gNewNewGWorld = false;
  447.     // this will work 9.x
  448.     Gestalt (gestaltSystemVersion, &versionSystem);
  449.     if (0x00000900 <= (versionSystem & 0x00000FF00))
  450.         gNewNewGWorld = true;
  451.     else
  452.     {
  453.         // now it is tricky
  454.         // we will try to allocate in VRAM and find out where the allocation really ended up.
  455.         GWorldPtr pgwTest = NULL;
  456.         Rect rectTest = {0, 0, 10, 10};
  457.         //short wPixDepth = (**((CGrafPtr)gpWindow)->portPixMap).pixelSize; // window pixel depth
  458.         short wPixDepth = (**(GetPortPixMap(GetWindowPort(gpWindow)))).pixelSize;
  459.         GDHandle hgdWindow = GetWindowDevice (gpWindow);    // window GDevice
  460.         if ((noErr == NewGWorld (&pgwTest, wPixDepth, &rectTest, NULL, hgdWindow, noNewDevice | useDistantHdwrMem)) &&
  461.             (pgwTest) /*&& // if we had a good allocation
  462.             //(GetZone () != HandleZone ((Handle)((**pgwTest->portPixMap).baseAddr)))) // if we did not allocate in our zone
  463.             (GetZone () != HandleZone ((Handle)((**(GetPortPixMap(pgwTest))).baseAddr)))*/)
  464.             gNewNewGWorld = true;    
  465.         if (pgwTest)
  466.             DisposeGWorld (pgwTest);
  467.     }        
  468.     if (!gNewNewGWorld)
  469.     {
  470.         hMenu = GetMenuHandle (kMenuFile);
  471.         for (i = kFileInVRAM; i <= kFileInAGP; i++)
  472.              //DisableItem (hMenu, i);
  473.              DisableMenuItem(hMenu, i);
  474.         AllocBuffer (kInSystem);
  475.     }
  476.     else
  477.         AllocBuffer (kInVRAM);
  478.     return true;
  479. }
  480.  
  481. // --------------------------------------------------------------------------
  482.  
  483. void DoMenu (SInt32 menuResult)
  484. {
  485.     SInt16 theMenu;
  486.     SInt16 theItem;
  487.     //Str255 daName;
  488.     MenuRef theMenuHandle;
  489.         
  490.     theMenu = HiWord(menuResult);
  491.     theItem = LoWord(menuResult);
  492.     theMenuHandle = GetMenuHandle(theMenu);
  493.  
  494.     switch (theMenu)
  495.     {
  496.         case kMenuApple:
  497.             switch (theItem)
  498.             {
  499.                 case kAppleAbout:
  500.                     break;
  501.                 default:
  502.                     //OpenDeskAcc(daName);
  503.                     break;
  504.             }
  505.             break;
  506.         case kMenuFile:
  507.             switch (theItem)
  508.             {
  509.                 case kFileInVRAM:
  510.                     AllocBuffer (kInVRAM);
  511.                     break;
  512.                 case kFileInAGP:
  513.                     AllocBuffer (kInAGP);
  514.                     break;
  515.                 case kFileInSystem:
  516.                     AllocBuffer (kInSystem);
  517.                     break;
  518.                 case kFileTest:
  519.                     RunTest ();
  520.                     break;
  521.                 case kFileQuit:
  522.                     gDone = true;
  523.                     break;
  524.             }
  525.             break;
  526.     }
  527.     HiliteMenu(0);
  528.     DrawMenuBar();
  529. }
  530.  
  531. // --------------------------------------------------------------------------
  532.  
  533. void DoKey (SInt8 theKey, SInt8 theCode)
  534. {
  535.     #pragma unused (theKey, theCode)
  536. }
  537.  
  538. // --------------------------------------------------------------------------
  539.  
  540. void DoUpdate (WindowPtr pWindow)
  541. {
  542.     BlitToWindow (gpGWOffScreen, pWindow, &gwLocOffscreen);
  543. }
  544.  
  545. // --------------------------------------------------------------------------
  546.  
  547. void DoEvent (void)
  548. {
  549.     EventRecord theEvent;
  550.     Rect rectGrow;
  551.     WindowRef whichWindow;
  552.     long grow;
  553.     SInt32 menuResult;
  554.     SInt16 whatPart;
  555.     SInt8 theKey;
  556.     SInt8 theCode;
  557.     RgnHandle rgnHandle = NewRgn();
  558.     Rect    tempRect1;
  559.     
  560.     if (WaitNextEvent(everyEvent, &theEvent, gSleepTime, NULL))
  561.     {
  562.         switch (theEvent.what)
  563.         {
  564.             case mouseDown:
  565.                 whatPart = FindWindow(theEvent.where, &whichWindow);
  566.                 switch (whatPart)
  567.                 {
  568.                     case inGoAway:
  569.                         break;
  570.                     case inMenuBar:
  571.                         DrawMenuBar();
  572.                         menuResult = MenuSelect(theEvent.where);
  573.                         if (HiWord(menuResult) != 0)
  574.                             DoMenu(menuResult);
  575.                         break;
  576.                     case inDrag:
  577.                         //DragWindow (whichWindow, theEvent.where, &(**LMGetGrayRgn()).rgnBBox);
  578.                         GetRegionBounds(GetGrayRgn(), &tempRect1);
  579.                         DragWindow (whichWindow, theEvent.where, &tempRect1);
  580.                         // ensure we are properly built
  581.                         if (BuildOffscreen (&gpGWOffScreen, gpWindow, &gwLocOffscreen))
  582.                         {
  583.                             FillOffscreen (gpGWOffScreen);
  584.                             BlitToWindow (gpGWOffScreen, gpWindow, &gwLocOffscreen);
  585.                         }
  586.                         break;
  587.                     case inGrow:
  588.                         SetRect (&rectGrow, 100, 100, 20000, 20000);
  589.                         grow = GrowWindow (whichWindow, theEvent.where, &rectGrow);
  590.                         if (grow)
  591.                         {
  592.                             SizeWindow (whichWindow, grow & 0x0000FFFF, grow >> 16, true);
  593.                             // ensure offscreen buffer is reallocated
  594.                             if (gpGWOffScreen)
  595.                                 DisposeGWorld (gpGWOffScreen);
  596.                             gpGWOffScreen = NULL;
  597.                             AllocBuffer (gwLocOffscreen);
  598.                             //SetPort (whichWindow);
  599.                             SetPortWindowPort(whichWindow);
  600.                             //InvalRect (&whichWindow->portRect);                // redraw all
  601.                             InvalWindowRect (whichWindow, &tempRect1);
  602.                         }
  603.                         break;
  604.                     case inSysWindow:
  605.                         //SystemClick(&theEvent, whichWindow);
  606.                         break;
  607.                 }
  608.                 break;
  609.             case keyDown:
  610.             case autoKey:
  611.                 theKey = theEvent.message & charCodeMask;
  612.                 theCode = (theEvent.message & keyCodeMask) >> 8;
  613.                 if ((theEvent.modifiers & cmdKey) != 0)
  614.                 {
  615.                     menuResult = MenuKey(theKey);
  616.                     if (HiWord(menuResult) != 0)
  617.                         DoMenu (menuResult);
  618.                 }
  619.                 else
  620.                     DoKey (theKey, theCode);
  621.                 break;
  622.             case updateEvt:
  623.                 BeginUpdate((WindowPtr) theEvent.message);
  624.                 DoUpdate((WindowPtr) theEvent.message);
  625.                 EndUpdate((WindowPtr) theEvent.message);
  626.                 break;
  627.             case diskEvt:
  628.                 break;
  629.             case osEvt:
  630.                 break;
  631.  
  632.             case kHighLevelEvent:
  633.                 AEProcessAppleEvent(&theEvent);
  634.                 break;
  635.             
  636.         }
  637.     }
  638.     else
  639.     {
  640.         // idle tasks
  641.     }
  642.     
  643.     DisposeRgn(rgnHandle);
  644. }
  645.  
  646. // --------------------------------------------------------------------------
  647.  
  648. void CleanUp (void)
  649. {
  650.     MenuHandle hMenu;
  651.  
  652.     HideWindow (gpWindow);
  653.     if (gpWindow)
  654.         DisposeWindow (gpWindow);
  655.     gpWindow = NULL;
  656.     
  657.     // this is VERY important since the GWorld may not be in the application heap zone
  658.     // leaked memory here outside the app heap may not be recoverable without a restart
  659.     if (gpGWOffScreen)
  660.         DisposeGWorld (gpGWOffScreen);
  661.     gpGWOffScreen = NULL;
  662.     
  663.     hMenu = GetMenuHandle (kMenuFile);
  664.     DeleteMenu (kMenuFile);
  665.     DisposeMenu (hMenu);
  666.  
  667.     hMenu = GetMenuHandle (kMenuApple);
  668.     DeleteMenu (kMenuApple);
  669.     DisposeMenu (hMenu);
  670. }
  671.  
  672. // --------------------------------------------------------------------------
  673.  
  674. int main (void)
  675. {
  676.     if (SetUp ())
  677.         while (!gDone)
  678.             DoEvent ();
  679.     CleanUp ();
  680.     return 0;
  681. }
  682.  
  683.  
  684.